// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.batch.details;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.BatchDetails;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(BatchDetails.class)
@Setter
@Getter
public class BatchDetailsSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "BatchDetails".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("tradeName", "p");
    map.put("shop", "si");
    map.put("wareHouse", "w");
    map.put("inboundDocuments", "si2");
    map.put("country", "sa");
    map.put("procurementPlanning", "pp");
    map.put("purchaseOrder", "po");
    map.put("goodsReceipt", "r");
    map.put("supplier", "s");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 批次号(模糊搜索)
   */
  private String batchNum;

  /**
   * 批次号 比较(eq)
   */
  private String batchNumEq;
  /**
   * 批次号 比较(neq)
   */
  private String batchNumNeq;
  /**
   * 批次号 比较(gt)
   */
  private String batchNumGt;
  /**
   * 批次号 比较(gte)
   */
  private String batchNumGte;
  /**
   * 批次号 比较(lt)
   */
  private String batchNumLt;
  /**
   * 批次号 比较(lte)
   */
  private String batchNumLte;
  /**
   * 批次号 比较(contains)
   */
  private String batchNumContains;
  /**
   * 批次号 比较(notcontains)
   */
  private String batchNumNotcontains;
  /**
   * 批次号 比较(startswith)
   */
  private String batchNumStartswith;
  /**
   * 批次号 比较(endswith)
   */
  private String batchNumEndswith;
  /**
   * 批次号 比较(isnull)
   */
  private Boolean batchNumIsnull;
  /**
   * 批次号 比较(isnotnull)
   */
  private Boolean batchNumIsnotnull;

  /**
   * 批次号(精确搜索)
   */
  private List<String> batchNumInList;

  /**
   * 入库类型
   */
  private String type;

  /**
   * 入库类型 比较(eq)
   */
  private String typeEq;
  /**
   * 入库类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 入库类型 比较(gt)
   */
  private String typeGt;
  /**
   * 入库类型 比较(gte)
   */
  private String typeGte;
  /**
   * 入库类型 比较(lt)
   */
  private String typeLt;
  /**
   * 入库类型 比较(lte)
   */
  private String typeLte;
  /**
   * 入库类型 比较(contains)
   */
  private String typeContains;
  /**
   * 入库类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 入库类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 入库类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 入库类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 入库类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 入库类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 品名
   */
  private Long tradeName;

  /**
   * 品名 比较(eq)
   */
  private Long tradeNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long tradeNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long tradeNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long tradeNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long tradeNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long tradeNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long tradeNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long tradeNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long tradeNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long tradeNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean tradeNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean tradeNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String tradeNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String tradeNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String tradeNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String tradeNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String tradeNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String tradeNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String tradeNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String tradeNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String tradeNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String tradeNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean tradeNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean tradeNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> tradeNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 店铺
   */
  private Long shop;

  /**
   * 店铺 比较(eq)
   */
  private Long shopEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnskuInList;

  /**
   * 仓库
   */
  private Long wareHouse;

  /**
   * 仓库 比较(eq)
   */
  private Long wareHouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long wareHouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long wareHouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long wareHouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long wareHouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long wareHouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long wareHouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long wareHouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long wareHouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long wareHouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean wareHouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean wareHouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String wareHouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String wareHouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String wareHouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String wareHouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String wareHouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String wareHouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String wareHouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String wareHouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String wareHouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String wareHouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean wareHouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean wareHouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> wareHouseInList;

  /**
   * 源头批次号(模糊搜索)
   */
  private String sourceBatchNumber;

  /**
   * 源头批次号 比较(eq)
   */
  private String sourceBatchNumberEq;
  /**
   * 源头批次号 比较(neq)
   */
  private String sourceBatchNumberNeq;
  /**
   * 源头批次号 比较(gt)
   */
  private String sourceBatchNumberGt;
  /**
   * 源头批次号 比较(gte)
   */
  private String sourceBatchNumberGte;
  /**
   * 源头批次号 比较(lt)
   */
  private String sourceBatchNumberLt;
  /**
   * 源头批次号 比较(lte)
   */
  private String sourceBatchNumberLte;
  /**
   * 源头批次号 比较(contains)
   */
  private String sourceBatchNumberContains;
  /**
   * 源头批次号 比较(notcontains)
   */
  private String sourceBatchNumberNotcontains;
  /**
   * 源头批次号 比较(startswith)
   */
  private String sourceBatchNumberStartswith;
  /**
   * 源头批次号 比较(endswith)
   */
  private String sourceBatchNumberEndswith;
  /**
   * 源头批次号 比较(isnull)
   */
  private Boolean sourceBatchNumberIsnull;
  /**
   * 源头批次号 比较(isnotnull)
   */
  private Boolean sourceBatchNumberIsnotnull;

  /**
   * 源头批次号(精确搜索)
   */
  private List<String> sourceBatchNumberInList;

  /**
   * 入库单据
   */
  private Long inboundDocuments;

  /**
   * 入库单据 比较(eq)
   */
  private Long inboundDocumentsEq;
  /**
   * 入库单据 比较(neq)
   */
  private Long inboundDocumentsNeq;
  /**
   * 入库单据 比较(gt)
   */
  private Long inboundDocumentsGt;
  /**
   * 入库单据 比较(gte)
   */
  private Long inboundDocumentsGte;
  /**
   * 入库单据 比较(lt)
   */
  private Long inboundDocumentsLt;
  /**
   * 入库单据 比较(lte)
   */
  private Long inboundDocumentsLte;
  /**
   * 入库单据 比较(contains)
   */
  private Long inboundDocumentsContains;
  /**
   * 入库单据 比较(notcontains)
   */
  private Long inboundDocumentsNotcontains;
  /**
   * 入库单据 比较(startswith)
   */
  private Long inboundDocumentsStartswith;
  /**
   * 入库单据 比较(endswith)
   */
  private Long inboundDocumentsEndswith;
  /**
   * 入库单据 比较(isnull)
   */
  private Boolean inboundDocumentsIsnull;
  /**
   * 入库单据 比较(isnotnull)
   */
  private Boolean inboundDocumentsIsnotnull;
  /**
   * 入库单据的采购员 比较(eq)
   */
  private String inboundDocumentsCgRealnameEq;
  /**
   * 入库单据的采购员 比较(neq)
   */
  private String inboundDocumentsCgRealnameNeq;
  /**
   * 入库单据的采购员 比较(gt)
   */
  private String inboundDocumentsCgRealnameGt;
  /**
   * 入库单据的采购员 比较(gte)
   */
  private String inboundDocumentsCgRealnameGte;
  /**
   * 入库单据的采购员 比较(lt)
   */
  private String inboundDocumentsCgRealnameLt;
  /**
   * 入库单据的采购员 比较(lte)
   */
  private String inboundDocumentsCgRealnameLte;
  /**
   * 入库单据的采购员 比较(contains)
   */
  private String inboundDocumentsCgRealnameContains;
  /**
   * 入库单据的采购员 比较(notcontains)
   */
  private String inboundDocumentsCgRealnameNotcontains;
  /**
   * 入库单据的采购员 比较(startswith)
   */
  private String inboundDocumentsCgRealnameStartswith;
  /**
   * 入库单据的采购员 比较(endswith)
   */
  private String inboundDocumentsCgRealnameEndswith;
  /**
   * 入库单据的采购员 比较(isnull)
   */
  private Boolean inboundDocumentsCgRealnameIsnull;
  /**
   * 入库单据的采购员 比较(isnotnull)
   */
  private Boolean inboundDocumentsCgRealnameIsnotnull;

  /**
   * 入库单据(范围搜索)
   */
  private List<Long> inboundDocumentsInList;

  /**
   * 最早操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operationTimeStart;

  /**
   * 最晚操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operationTimeEnd;

  /**
   * 操作时间 比较(eq)
   */
  private Date operationTimeEq;
  /**
   * 操作时间 比较(neq)
   */
  private Date operationTimeNeq;
  /**
   * 操作时间 比较(gt)
   */
  private Date operationTimeGt;
  /**
   * 操作时间 比较(gte)
   */
  private Date operationTimeGte;
  /**
   * 操作时间 比较(lt)
   */
  private Date operationTimeLt;
  /**
   * 操作时间 比较(lte)
   */
  private Date operationTimeLte;
  /**
   * 操作时间 比较(contains)
   */
  private Date operationTimeContains;
  /**
   * 操作时间 比较(notcontains)
   */
  private Date operationTimeNotcontains;
  /**
   * 操作时间 比较(startswith)
   */
  private Date operationTimeStartswith;
  /**
   * 操作时间 比较(endswith)
   */
  private Date operationTimeEndswith;
  /**
   * 操作时间 比较(isnull)
   */
  private Boolean operationTimeIsnull;
  /**
   * 操作时间 比较(isnotnull)
   */
  private Boolean operationTimeIsnotnull;

  /**
   * 最早入库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date inboundTimeStart;

  /**
   * 最晚入库时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date inboundTimeEnd;

  /**
   * 入库时间 比较(eq)
   */
  private Date inboundTimeEq;
  /**
   * 入库时间 比较(neq)
   */
  private Date inboundTimeNeq;
  /**
   * 入库时间 比较(gt)
   */
  private Date inboundTimeGt;
  /**
   * 入库时间 比较(gte)
   */
  private Date inboundTimeGte;
  /**
   * 入库时间 比较(lt)
   */
  private Date inboundTimeLt;
  /**
   * 入库时间 比较(lte)
   */
  private Date inboundTimeLte;
  /**
   * 入库时间 比较(contains)
   */
  private Date inboundTimeContains;
  /**
   * 入库时间 比较(notcontains)
   */
  private Date inboundTimeNotcontains;
  /**
   * 入库时间 比较(startswith)
   */
  private Date inboundTimeStartswith;
  /**
   * 入库时间 比较(endswith)
   */
  private Date inboundTimeEndswith;
  /**
   * 入库时间 比较(isnull)
   */
  private Boolean inboundTimeIsnull;
  /**
   * 入库时间 比较(isnotnull)
   */
  private Boolean inboundTimeIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean img;

  /**
   * 国家（地区）
   */
  private Long country;

  /**
   * 国家（地区） 比较(eq)
   */
  private Long countryEq;
  /**
   * 国家（地区） 比较(neq)
   */
  private Long countryNeq;
  /**
   * 国家（地区） 比较(gt)
   */
  private Long countryGt;
  /**
   * 国家（地区） 比较(gte)
   */
  private Long countryGte;
  /**
   * 国家（地区） 比较(lt)
   */
  private Long countryLt;
  /**
   * 国家（地区） 比较(lte)
   */
  private Long countryLte;
  /**
   * 国家（地区） 比较(contains)
   */
  private Long countryContains;
  /**
   * 国家（地区） 比较(notcontains)
   */
  private Long countryNotcontains;
  /**
   * 国家（地区） 比较(startswith)
   */
  private Long countryStartswith;
  /**
   * 国家（地区） 比较(endswith)
   */
  private Long countryEndswith;
  /**
   * 国家（地区） 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家（地区） 比较(isnotnull)
   */
  private Boolean countryIsnotnull;
  /**
   * 国家（地区）的区域名称 比较(eq)
   */
  private String countryNameEq;
  /**
   * 国家（地区）的区域名称 比较(neq)
   */
  private String countryNameNeq;
  /**
   * 国家（地区）的区域名称 比较(gt)
   */
  private String countryNameGt;
  /**
   * 国家（地区）的区域名称 比较(gte)
   */
  private String countryNameGte;
  /**
   * 国家（地区）的区域名称 比较(lt)
   */
  private String countryNameLt;
  /**
   * 国家（地区）的区域名称 比较(lte)
   */
  private String countryNameLte;
  /**
   * 国家（地区）的区域名称 比较(contains)
   */
  private String countryNameContains;
  /**
   * 国家（地区）的区域名称 比较(notcontains)
   */
  private String countryNameNotcontains;
  /**
   * 国家（地区）的区域名称 比较(startswith)
   */
  private String countryNameStartswith;
  /**
   * 国家（地区）的区域名称 比较(endswith)
   */
  private String countryNameEndswith;
  /**
   * 国家（地区）的区域名称 比较(isnull)
   */
  private Boolean countryNameIsnull;
  /**
   * 国家（地区）的区域名称 比较(isnotnull)
   */
  private Boolean countryNameIsnotnull;

  /**
   * 国家（地区）(范围搜索)
   */
  private List<Long> countryInList;

  /**
   * 总数
   */
  private Integer total;

  /**
   * 最小总数
   */
  private Integer totalMin;

  /**
   * 最大总数
   */
  private Integer totalMax;

  /**
   * 总数 比较(eq)
   */
  private Integer totalEq;
  /**
   * 总数 比较(neq)
   */
  private Integer totalNeq;
  /**
   * 总数 比较(gt)
   */
  private Integer totalGt;
  /**
   * 总数 比较(gte)
   */
  private Integer totalGte;
  /**
   * 总数 比较(lt)
   */
  private Integer totalLt;
  /**
   * 总数 比较(lte)
   */
  private Integer totalLte;
  /**
   * 总数 比较(contains)
   */
  private Integer totalContains;
  /**
   * 总数 比较(notcontains)
   */
  private Integer totalNotcontains;
  /**
   * 总数 比较(startswith)
   */
  private Integer totalStartswith;
  /**
   * 总数 比较(endswith)
   */
  private Integer totalEndswith;
  /**
   * 总数 比较(isnull)
   */
  private Boolean totalIsnull;
  /**
   * 总数 比较(isnotnull)
   */
  private Boolean totalIsnotnull;

  /**
   * 在途量
   */
  private Integer inTransit;

  /**
   * 最小在途量
   */
  private Integer inTransitMin;

  /**
   * 最大在途量
   */
  private Integer inTransitMax;

  /**
   * 在途量 比较(eq)
   */
  private Integer inTransitEq;
  /**
   * 在途量 比较(neq)
   */
  private Integer inTransitNeq;
  /**
   * 在途量 比较(gt)
   */
  private Integer inTransitGt;
  /**
   * 在途量 比较(gte)
   */
  private Integer inTransitGte;
  /**
   * 在途量 比较(lt)
   */
  private Integer inTransitLt;
  /**
   * 在途量 比较(lte)
   */
  private Integer inTransitLte;
  /**
   * 在途量 比较(contains)
   */
  private Integer inTransitContains;
  /**
   * 在途量 比较(notcontains)
   */
  private Integer inTransitNotcontains;
  /**
   * 在途量 比较(startswith)
   */
  private Integer inTransitStartswith;
  /**
   * 在途量 比较(endswith)
   */
  private Integer inTransitEndswith;
  /**
   * 在途量 比较(isnull)
   */
  private Boolean inTransitIsnull;
  /**
   * 在途量 比较(isnotnull)
   */
  private Boolean inTransitIsnotnull;

  /**
   * 在库量
   */
  private Integer amountInStock;

  /**
   * 最小在库量
   */
  private Integer amountInStockMin;

  /**
   * 最大在库量
   */
  private Integer amountInStockMax;

  /**
   * 在库量 比较(eq)
   */
  private Integer amountInStockEq;
  /**
   * 在库量 比较(neq)
   */
  private Integer amountInStockNeq;
  /**
   * 在库量 比较(gt)
   */
  private Integer amountInStockGt;
  /**
   * 在库量 比较(gte)
   */
  private Integer amountInStockGte;
  /**
   * 在库量 比较(lt)
   */
  private Integer amountInStockLt;
  /**
   * 在库量 比较(lte)
   */
  private Integer amountInStockLte;
  /**
   * 在库量 比较(contains)
   */
  private Integer amountInStockContains;
  /**
   * 在库量 比较(notcontains)
   */
  private Integer amountInStockNotcontains;
  /**
   * 在库量 比较(startswith)
   */
  private Integer amountInStockStartswith;
  /**
   * 在库量 比较(endswith)
   */
  private Integer amountInStockEndswith;
  /**
   * 在库量 比较(isnull)
   */
  private Boolean amountInStockIsnull;
  /**
   * 在库量 比较(isnotnull)
   */
  private Boolean amountInStockIsnotnull;

  /**
   * 可用在途量
   */
  private Integer availableInTransit;

  /**
   * 最小可用在途量
   */
  private Integer availableInTransitMin;

  /**
   * 最大可用在途量
   */
  private Integer availableInTransitMax;

  /**
   * 可用在途量 比较(eq)
   */
  private Integer availableInTransitEq;
  /**
   * 可用在途量 比较(neq)
   */
  private Integer availableInTransitNeq;
  /**
   * 可用在途量 比较(gt)
   */
  private Integer availableInTransitGt;
  /**
   * 可用在途量 比较(gte)
   */
  private Integer availableInTransitGte;
  /**
   * 可用在途量 比较(lt)
   */
  private Integer availableInTransitLt;
  /**
   * 可用在途量 比较(lte)
   */
  private Integer availableInTransitLte;
  /**
   * 可用在途量 比较(contains)
   */
  private Integer availableInTransitContains;
  /**
   * 可用在途量 比较(notcontains)
   */
  private Integer availableInTransitNotcontains;
  /**
   * 可用在途量 比较(startswith)
   */
  private Integer availableInTransitStartswith;
  /**
   * 可用在途量 比较(endswith)
   */
  private Integer availableInTransitEndswith;
  /**
   * 可用在途量 比较(isnull)
   */
  private Boolean availableInTransitIsnull;
  /**
   * 可用在途量 比较(isnotnull)
   */
  private Boolean availableInTransitIsnotnull;

  /**
   * 次品在途量
   */
  private Integer defectiveProductsInTransit;

  /**
   * 最小次品在途量
   */
  private Integer defectiveProductsInTransitMin;

  /**
   * 最大次品在途量
   */
  private Integer defectiveProductsInTransitMax;

  /**
   * 次品在途量 比较(eq)
   */
  private Integer defectiveProductsInTransitEq;
  /**
   * 次品在途量 比较(neq)
   */
  private Integer defectiveProductsInTransitNeq;
  /**
   * 次品在途量 比较(gt)
   */
  private Integer defectiveProductsInTransitGt;
  /**
   * 次品在途量 比较(gte)
   */
  private Integer defectiveProductsInTransitGte;
  /**
   * 次品在途量 比较(lt)
   */
  private Integer defectiveProductsInTransitLt;
  /**
   * 次品在途量 比较(lte)
   */
  private Integer defectiveProductsInTransitLte;
  /**
   * 次品在途量 比较(contains)
   */
  private Integer defectiveProductsInTransitContains;
  /**
   * 次品在途量 比较(notcontains)
   */
  private Integer defectiveProductsInTransitNotcontains;
  /**
   * 次品在途量 比较(startswith)
   */
  private Integer defectiveProductsInTransitStartswith;
  /**
   * 次品在途量 比较(endswith)
   */
  private Integer defectiveProductsInTransitEndswith;
  /**
   * 次品在途量 比较(isnull)
   */
  private Boolean defectiveProductsInTransitIsnull;
  /**
   * 次品在途量 比较(isnotnull)
   */
  private Boolean defectiveProductsInTransitIsnotnull;

  /**
   * 待检量
   */
  private Integer amountInspected;

  /**
   * 最小待检量
   */
  private Integer amountInspectedMin;

  /**
   * 最大待检量
   */
  private Integer amountInspectedMax;

  /**
   * 待检量 比较(eq)
   */
  private Integer amountInspectedEq;
  /**
   * 待检量 比较(neq)
   */
  private Integer amountInspectedNeq;
  /**
   * 待检量 比较(gt)
   */
  private Integer amountInspectedGt;
  /**
   * 待检量 比较(gte)
   */
  private Integer amountInspectedGte;
  /**
   * 待检量 比较(lt)
   */
  private Integer amountInspectedLt;
  /**
   * 待检量 比较(lte)
   */
  private Integer amountInspectedLte;
  /**
   * 待检量 比较(contains)
   */
  private Integer amountInspectedContains;
  /**
   * 待检量 比较(notcontains)
   */
  private Integer amountInspectedNotcontains;
  /**
   * 待检量 比较(startswith)
   */
  private Integer amountInspectedStartswith;
  /**
   * 待检量 比较(endswith)
   */
  private Integer amountInspectedEndswith;
  /**
   * 待检量 比较(isnull)
   */
  private Boolean amountInspectedIsnull;
  /**
   * 待检量 比较(isnotnull)
   */
  private Boolean amountInspectedIsnotnull;

  /**
   * 可用量
   */
  private Integer availableAmount;

  /**
   * 最小可用量
   */
  private Integer availableAmountMin;

  /**
   * 最大可用量
   */
  private Integer availableAmountMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer availableAmountEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer availableAmountNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer availableAmountGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer availableAmountGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer availableAmountLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer availableAmountLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer availableAmountContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer availableAmountNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer availableAmountStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer availableAmountEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean availableAmountIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean availableAmountIsnotnull;

  /**
   * 次品量
   */
  private Integer defectiveQuantity;

  /**
   * 最小次品量
   */
  private Integer defectiveQuantityMin;

  /**
   * 最大次品量
   */
  private Integer defectiveQuantityMax;

  /**
   * 次品量 比较(eq)
   */
  private Integer defectiveQuantityEq;
  /**
   * 次品量 比较(neq)
   */
  private Integer defectiveQuantityNeq;
  /**
   * 次品量 比较(gt)
   */
  private Integer defectiveQuantityGt;
  /**
   * 次品量 比较(gte)
   */
  private Integer defectiveQuantityGte;
  /**
   * 次品量 比较(lt)
   */
  private Integer defectiveQuantityLt;
  /**
   * 次品量 比较(lte)
   */
  private Integer defectiveQuantityLte;
  /**
   * 次品量 比较(contains)
   */
  private Integer defectiveQuantityContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Integer defectiveQuantityNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Integer defectiveQuantityStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Integer defectiveQuantityEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean defectiveQuantityIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean defectiveQuantityIsnotnull;

  /**
   * 采购单价
   */
  private java.math.BigDecimal purchaseUnitPrice;

  /**
   * 最小采购单价
   */
  private java.math.BigDecimal purchaseUnitPriceMin;

  /**
   * 最大采购单价
   */
  private java.math.BigDecimal purchaseUnitPriceMax;

  /**
   * 采购单价 比较(eq)
   */
  private java.math.BigDecimal purchaseUnitPriceEq;
  /**
   * 采购单价 比较(neq)
   */
  private java.math.BigDecimal purchaseUnitPriceNeq;
  /**
   * 采购单价 比较(gt)
   */
  private java.math.BigDecimal purchaseUnitPriceGt;
  /**
   * 采购单价 比较(gte)
   */
  private java.math.BigDecimal purchaseUnitPriceGte;
  /**
   * 采购单价 比较(lt)
   */
  private java.math.BigDecimal purchaseUnitPriceLt;
  /**
   * 采购单价 比较(lte)
   */
  private java.math.BigDecimal purchaseUnitPriceLte;
  /**
   * 采购单价 比较(contains)
   */
  private java.math.BigDecimal purchaseUnitPriceContains;
  /**
   * 采购单价 比较(notcontains)
   */
  private java.math.BigDecimal purchaseUnitPriceNotcontains;
  /**
   * 采购单价 比较(startswith)
   */
  private java.math.BigDecimal purchaseUnitPriceStartswith;
  /**
   * 采购单价 比较(endswith)
   */
  private java.math.BigDecimal purchaseUnitPriceEndswith;
  /**
   * 采购单价 比较(isnull)
   */
  private Boolean purchaseUnitPriceIsnull;
  /**
   * 采购单价 比较(isnotnull)
   */
  private Boolean purchaseUnitPriceIsnotnull;

  /**
   * 单位费用
   */
  private java.math.BigDecimal unitCosts;

  /**
   * 最小单位费用
   */
  private java.math.BigDecimal unitCostsMin;

  /**
   * 最大单位费用
   */
  private java.math.BigDecimal unitCostsMax;

  /**
   * 单位费用 比较(eq)
   */
  private java.math.BigDecimal unitCostsEq;
  /**
   * 单位费用 比较(neq)
   */
  private java.math.BigDecimal unitCostsNeq;
  /**
   * 单位费用 比较(gt)
   */
  private java.math.BigDecimal unitCostsGt;
  /**
   * 单位费用 比较(gte)
   */
  private java.math.BigDecimal unitCostsGte;
  /**
   * 单位费用 比较(lt)
   */
  private java.math.BigDecimal unitCostsLt;
  /**
   * 单位费用 比较(lte)
   */
  private java.math.BigDecimal unitCostsLte;
  /**
   * 单位费用 比较(contains)
   */
  private java.math.BigDecimal unitCostsContains;
  /**
   * 单位费用 比较(notcontains)
   */
  private java.math.BigDecimal unitCostsNotcontains;
  /**
   * 单位费用 比较(startswith)
   */
  private java.math.BigDecimal unitCostsStartswith;
  /**
   * 单位费用 比较(endswith)
   */
  private java.math.BigDecimal unitCostsEndswith;
  /**
   * 单位费用 比较(isnull)
   */
  private Boolean unitCostsIsnull;
  /**
   * 单位费用 比较(isnotnull)
   */
  private Boolean unitCostsIsnotnull;

  /**
   * 单位头程
   */
  private java.math.BigDecimal unitHeadStroke;

  /**
   * 最小单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMin;

  /**
   * 最大单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMax;

  /**
   * 单位头程 比较(eq)
   */
  private java.math.BigDecimal unitHeadStrokeEq;
  /**
   * 单位头程 比较(neq)
   */
  private java.math.BigDecimal unitHeadStrokeNeq;
  /**
   * 单位头程 比较(gt)
   */
  private java.math.BigDecimal unitHeadStrokeGt;
  /**
   * 单位头程 比较(gte)
   */
  private java.math.BigDecimal unitHeadStrokeGte;
  /**
   * 单位头程 比较(lt)
   */
  private java.math.BigDecimal unitHeadStrokeLt;
  /**
   * 单位头程 比较(lte)
   */
  private java.math.BigDecimal unitHeadStrokeLte;
  /**
   * 单位头程 比较(contains)
   */
  private java.math.BigDecimal unitHeadStrokeContains;
  /**
   * 单位头程 比较(notcontains)
   */
  private java.math.BigDecimal unitHeadStrokeNotcontains;
  /**
   * 单位头程 比较(startswith)
   */
  private java.math.BigDecimal unitHeadStrokeStartswith;
  /**
   * 单位头程 比较(endswith)
   */
  private java.math.BigDecimal unitHeadStrokeEndswith;
  /**
   * 单位头程 比较(isnull)
   */
  private Boolean unitHeadStrokeIsnull;
  /**
   * 单位头程 比较(isnotnull)
   */
  private Boolean unitHeadStrokeIsnotnull;

  /**
   * 单位库存成本
   */
  private java.math.BigDecimal unitInventoryCost;

  /**
   * 最小单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMin;

  /**
   * 最大单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMax;

  /**
   * 单位库存成本 比较(eq)
   */
  private java.math.BigDecimal unitInventoryCostEq;
  /**
   * 单位库存成本 比较(neq)
   */
  private java.math.BigDecimal unitInventoryCostNeq;
  /**
   * 单位库存成本 比较(gt)
   */
  private java.math.BigDecimal unitInventoryCostGt;
  /**
   * 单位库存成本 比较(gte)
   */
  private java.math.BigDecimal unitInventoryCostGte;
  /**
   * 单位库存成本 比较(lt)
   */
  private java.math.BigDecimal unitInventoryCostLt;
  /**
   * 单位库存成本 比较(lte)
   */
  private java.math.BigDecimal unitInventoryCostLte;
  /**
   * 单位库存成本 比较(contains)
   */
  private java.math.BigDecimal unitInventoryCostContains;
  /**
   * 单位库存成本 比较(notcontains)
   */
  private java.math.BigDecimal unitInventoryCostNotcontains;
  /**
   * 单位库存成本 比较(startswith)
   */
  private java.math.BigDecimal unitInventoryCostStartswith;
  /**
   * 单位库存成本 比较(endswith)
   */
  private java.math.BigDecimal unitInventoryCostEndswith;
  /**
   * 单位库存成本 比较(isnull)
   */
  private Boolean unitInventoryCostIsnull;
  /**
   * 单位库存成本 比较(isnotnull)
   */
  private Boolean unitInventoryCostIsnotnull;

  /**
   * 货值
   */
  private java.math.BigDecimal goodsValue;

  /**
   * 最小货值
   */
  private java.math.BigDecimal goodsValueMin;

  /**
   * 最大货值
   */
  private java.math.BigDecimal goodsValueMax;

  /**
   * 货值 比较(eq)
   */
  private java.math.BigDecimal goodsValueEq;
  /**
   * 货值 比较(neq)
   */
  private java.math.BigDecimal goodsValueNeq;
  /**
   * 货值 比较(gt)
   */
  private java.math.BigDecimal goodsValueGt;
  /**
   * 货值 比较(gte)
   */
  private java.math.BigDecimal goodsValueGte;
  /**
   * 货值 比较(lt)
   */
  private java.math.BigDecimal goodsValueLt;
  /**
   * 货值 比较(lte)
   */
  private java.math.BigDecimal goodsValueLte;
  /**
   * 货值 比较(contains)
   */
  private java.math.BigDecimal goodsValueContains;
  /**
   * 货值 比较(notcontains)
   */
  private java.math.BigDecimal goodsValueNotcontains;
  /**
   * 货值 比较(startswith)
   */
  private java.math.BigDecimal goodsValueStartswith;
  /**
   * 货值 比较(endswith)
   */
  private java.math.BigDecimal goodsValueEndswith;
  /**
   * 货值 比较(isnull)
   */
  private Boolean goodsValueIsnull;
  /**
   * 货值 比较(isnotnull)
   */
  private Boolean goodsValueIsnotnull;

  /**
   * 费用
   */
  private java.math.BigDecimal expenses;

  /**
   * 最小费用
   */
  private java.math.BigDecimal expensesMin;

  /**
   * 最大费用
   */
  private java.math.BigDecimal expensesMax;

  /**
   * 费用 比较(eq)
   */
  private java.math.BigDecimal expensesEq;
  /**
   * 费用 比较(neq)
   */
  private java.math.BigDecimal expensesNeq;
  /**
   * 费用 比较(gt)
   */
  private java.math.BigDecimal expensesGt;
  /**
   * 费用 比较(gte)
   */
  private java.math.BigDecimal expensesGte;
  /**
   * 费用 比较(lt)
   */
  private java.math.BigDecimal expensesLt;
  /**
   * 费用 比较(lte)
   */
  private java.math.BigDecimal expensesLte;
  /**
   * 费用 比较(contains)
   */
  private java.math.BigDecimal expensesContains;
  /**
   * 费用 比较(notcontains)
   */
  private java.math.BigDecimal expensesNotcontains;
  /**
   * 费用 比较(startswith)
   */
  private java.math.BigDecimal expensesStartswith;
  /**
   * 费用 比较(endswith)
   */
  private java.math.BigDecimal expensesEndswith;
  /**
   * 费用 比较(isnull)
   */
  private Boolean expensesIsnull;
  /**
   * 费用 比较(isnotnull)
   */
  private Boolean expensesIsnotnull;

  /**
   * 头程
   */
  private java.math.BigDecimal headStroke;

  /**
   * 最小头程
   */
  private java.math.BigDecimal headStrokeMin;

  /**
   * 最大头程
   */
  private java.math.BigDecimal headStrokeMax;

  /**
   * 头程 比较(eq)
   */
  private java.math.BigDecimal headStrokeEq;
  /**
   * 头程 比较(neq)
   */
  private java.math.BigDecimal headStrokeNeq;
  /**
   * 头程 比较(gt)
   */
  private java.math.BigDecimal headStrokeGt;
  /**
   * 头程 比较(gte)
   */
  private java.math.BigDecimal headStrokeGte;
  /**
   * 头程 比较(lt)
   */
  private java.math.BigDecimal headStrokeLt;
  /**
   * 头程 比较(lte)
   */
  private java.math.BigDecimal headStrokeLte;
  /**
   * 头程 比较(contains)
   */
  private java.math.BigDecimal headStrokeContains;
  /**
   * 头程 比较(notcontains)
   */
  private java.math.BigDecimal headStrokeNotcontains;
  /**
   * 头程 比较(startswith)
   */
  private java.math.BigDecimal headStrokeStartswith;
  /**
   * 头程 比较(endswith)
   */
  private java.math.BigDecimal headStrokeEndswith;
  /**
   * 头程 比较(isnull)
   */
  private Boolean headStrokeIsnull;
  /**
   * 头程 比较(isnotnull)
   */
  private Boolean headStrokeIsnotnull;

  /**
   * 库存成本
   */
  private java.math.BigDecimal inventoryCost;

  /**
   * 最小库存成本
   */
  private java.math.BigDecimal inventoryCostMin;

  /**
   * 最大库存成本
   */
  private java.math.BigDecimal inventoryCostMax;

  /**
   * 库存成本 比较(eq)
   */
  private java.math.BigDecimal inventoryCostEq;
  /**
   * 库存成本 比较(neq)
   */
  private java.math.BigDecimal inventoryCostNeq;
  /**
   * 库存成本 比较(gt)
   */
  private java.math.BigDecimal inventoryCostGt;
  /**
   * 库存成本 比较(gte)
   */
  private java.math.BigDecimal inventoryCostGte;
  /**
   * 库存成本 比较(lt)
   */
  private java.math.BigDecimal inventoryCostLt;
  /**
   * 库存成本 比较(lte)
   */
  private java.math.BigDecimal inventoryCostLte;
  /**
   * 库存成本 比较(contains)
   */
  private java.math.BigDecimal inventoryCostContains;
  /**
   * 库存成本 比较(notcontains)
   */
  private java.math.BigDecimal inventoryCostNotcontains;
  /**
   * 库存成本 比较(startswith)
   */
  private java.math.BigDecimal inventoryCostStartswith;
  /**
   * 库存成本 比较(endswith)
   */
  private java.math.BigDecimal inventoryCostEndswith;
  /**
   * 库存成本 比较(isnull)
   */
  private Boolean inventoryCostIsnull;
  /**
   * 库存成本 比较(isnotnull)
   */
  private Boolean inventoryCostIsnotnull;

  /**
   * 采购计划
   */
  private Long procurementPlanning;

  /**
   * 采购计划 比较(eq)
   */
  private Long procurementPlanningEq;
  /**
   * 采购计划 比较(neq)
   */
  private Long procurementPlanningNeq;
  /**
   * 采购计划 比较(gt)
   */
  private Long procurementPlanningGt;
  /**
   * 采购计划 比较(gte)
   */
  private Long procurementPlanningGte;
  /**
   * 采购计划 比较(lt)
   */
  private Long procurementPlanningLt;
  /**
   * 采购计划 比较(lte)
   */
  private Long procurementPlanningLte;
  /**
   * 采购计划 比较(contains)
   */
  private Long procurementPlanningContains;
  /**
   * 采购计划 比较(notcontains)
   */
  private Long procurementPlanningNotcontains;
  /**
   * 采购计划 比较(startswith)
   */
  private Long procurementPlanningStartswith;
  /**
   * 采购计划 比较(endswith)
   */
  private Long procurementPlanningEndswith;
  /**
   * 采购计划 比较(isnull)
   */
  private Boolean procurementPlanningIsnull;
  /**
   * 采购计划 比较(isnotnull)
   */
  private Boolean procurementPlanningIsnotnull;
  /**
   * 采购计划的创建批次号 比较(eq)
   */
  private String procurementPlanningPpgSnEq;
  /**
   * 采购计划的创建批次号 比较(neq)
   */
  private String procurementPlanningPpgSnNeq;
  /**
   * 采购计划的创建批次号 比较(gt)
   */
  private String procurementPlanningPpgSnGt;
  /**
   * 采购计划的创建批次号 比较(gte)
   */
  private String procurementPlanningPpgSnGte;
  /**
   * 采购计划的创建批次号 比较(lt)
   */
  private String procurementPlanningPpgSnLt;
  /**
   * 采购计划的创建批次号 比较(lte)
   */
  private String procurementPlanningPpgSnLte;
  /**
   * 采购计划的创建批次号 比较(contains)
   */
  private String procurementPlanningPpgSnContains;
  /**
   * 采购计划的创建批次号 比较(notcontains)
   */
  private String procurementPlanningPpgSnNotcontains;
  /**
   * 采购计划的创建批次号 比较(startswith)
   */
  private String procurementPlanningPpgSnStartswith;
  /**
   * 采购计划的创建批次号 比较(endswith)
   */
  private String procurementPlanningPpgSnEndswith;
  /**
   * 采购计划的创建批次号 比较(isnull)
   */
  private Boolean procurementPlanningPpgSnIsnull;
  /**
   * 采购计划的创建批次号 比较(isnotnull)
   */
  private Boolean procurementPlanningPpgSnIsnotnull;

  /**
   * 采购计划(范围搜索)
   */
  private List<Long> procurementPlanningInList;

  /**
   * 采购单
   */
  private Long purchaseOrder;

  /**
   * 采购单 比较(eq)
   */
  private Long purchaseOrderEq;
  /**
   * 采购单 比较(neq)
   */
  private Long purchaseOrderNeq;
  /**
   * 采购单 比较(gt)
   */
  private Long purchaseOrderGt;
  /**
   * 采购单 比较(gte)
   */
  private Long purchaseOrderGte;
  /**
   * 采购单 比较(lt)
   */
  private Long purchaseOrderLt;
  /**
   * 采购单 比较(lte)
   */
  private Long purchaseOrderLte;
  /**
   * 采购单 比较(contains)
   */
  private Long purchaseOrderContains;
  /**
   * 采购单 比较(notcontains)
   */
  private Long purchaseOrderNotcontains;
  /**
   * 采购单 比较(startswith)
   */
  private Long purchaseOrderStartswith;
  /**
   * 采购单 比较(endswith)
   */
  private Long purchaseOrderEndswith;
  /**
   * 采购单 比较(isnull)
   */
  private Boolean purchaseOrderIsnull;
  /**
   * 采购单 比较(isnotnull)
   */
  private Boolean purchaseOrderIsnotnull;
  /**
   * 采购单的采购单号 比较(eq)
   */
  private String purchaseOrderPurchaseOrderCodeEq;
  /**
   * 采购单的采购单号 比较(neq)
   */
  private String purchaseOrderPurchaseOrderCodeNeq;
  /**
   * 采购单的采购单号 比较(gt)
   */
  private String purchaseOrderPurchaseOrderCodeGt;
  /**
   * 采购单的采购单号 比较(gte)
   */
  private String purchaseOrderPurchaseOrderCodeGte;
  /**
   * 采购单的采购单号 比较(lt)
   */
  private String purchaseOrderPurchaseOrderCodeLt;
  /**
   * 采购单的采购单号 比较(lte)
   */
  private String purchaseOrderPurchaseOrderCodeLte;
  /**
   * 采购单的采购单号 比较(contains)
   */
  private String purchaseOrderPurchaseOrderCodeContains;
  /**
   * 采购单的采购单号 比较(notcontains)
   */
  private String purchaseOrderPurchaseOrderCodeNotcontains;
  /**
   * 采购单的采购单号 比较(startswith)
   */
  private String purchaseOrderPurchaseOrderCodeStartswith;
  /**
   * 采购单的采购单号 比较(endswith)
   */
  private String purchaseOrderPurchaseOrderCodeEndswith;
  /**
   * 采购单的采购单号 比较(isnull)
   */
  private Boolean purchaseOrderPurchaseOrderCodeIsnull;
  /**
   * 采购单的采购单号 比较(isnotnull)
   */
  private Boolean purchaseOrderPurchaseOrderCodeIsnotnull;

  /**
   * 采购单(范围搜索)
   */
  private List<Long> purchaseOrderInList;

  /**
   * 收货单
   */
  private Long goodsReceipt;

  /**
   * 收货单 比较(eq)
   */
  private Long goodsReceiptEq;
  /**
   * 收货单 比较(neq)
   */
  private Long goodsReceiptNeq;
  /**
   * 收货单 比较(gt)
   */
  private Long goodsReceiptGt;
  /**
   * 收货单 比较(gte)
   */
  private Long goodsReceiptGte;
  /**
   * 收货单 比较(lt)
   */
  private Long goodsReceiptLt;
  /**
   * 收货单 比较(lte)
   */
  private Long goodsReceiptLte;
  /**
   * 收货单 比较(contains)
   */
  private Long goodsReceiptContains;
  /**
   * 收货单 比较(notcontains)
   */
  private Long goodsReceiptNotcontains;
  /**
   * 收货单 比较(startswith)
   */
  private Long goodsReceiptStartswith;
  /**
   * 收货单 比较(endswith)
   */
  private Long goodsReceiptEndswith;
  /**
   * 收货单 比较(isnull)
   */
  private Boolean goodsReceiptIsnull;
  /**
   * 收货单 比较(isnotnull)
   */
  private Boolean goodsReceiptIsnotnull;
  /**
   * 收货单的收货单号 比较(eq)
   */
  private String goodsReceiptOrderSnEq;
  /**
   * 收货单的收货单号 比较(neq)
   */
  private String goodsReceiptOrderSnNeq;
  /**
   * 收货单的收货单号 比较(gt)
   */
  private String goodsReceiptOrderSnGt;
  /**
   * 收货单的收货单号 比较(gte)
   */
  private String goodsReceiptOrderSnGte;
  /**
   * 收货单的收货单号 比较(lt)
   */
  private String goodsReceiptOrderSnLt;
  /**
   * 收货单的收货单号 比较(lte)
   */
  private String goodsReceiptOrderSnLte;
  /**
   * 收货单的收货单号 比较(contains)
   */
  private String goodsReceiptOrderSnContains;
  /**
   * 收货单的收货单号 比较(notcontains)
   */
  private String goodsReceiptOrderSnNotcontains;
  /**
   * 收货单的收货单号 比较(startswith)
   */
  private String goodsReceiptOrderSnStartswith;
  /**
   * 收货单的收货单号 比较(endswith)
   */
  private String goodsReceiptOrderSnEndswith;
  /**
   * 收货单的收货单号 比较(isnull)
   */
  private Boolean goodsReceiptOrderSnIsnull;
  /**
   * 收货单的收货单号 比较(isnotnull)
   */
  private Boolean goodsReceiptOrderSnIsnotnull;

  /**
   * 收货单(范围搜索)
   */
  private List<Long> goodsReceiptInList;

  /**
   * 供应商
   */
  private Long supplier;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierInList;

  /**
   * 在库库龄
   */
  private Integer ageInTheLibrary;

  /**
   * 最小在库库龄
   */
  private Integer ageInTheLibraryMin;

  /**
   * 最大在库库龄
   */
  private Integer ageInTheLibraryMax;

  /**
   * 在库库龄 比较(eq)
   */
  private Integer ageInTheLibraryEq;
  /**
   * 在库库龄 比较(neq)
   */
  private Integer ageInTheLibraryNeq;
  /**
   * 在库库龄 比较(gt)
   */
  private Integer ageInTheLibraryGt;
  /**
   * 在库库龄 比较(gte)
   */
  private Integer ageInTheLibraryGte;
  /**
   * 在库库龄 比较(lt)
   */
  private Integer ageInTheLibraryLt;
  /**
   * 在库库龄 比较(lte)
   */
  private Integer ageInTheLibraryLte;
  /**
   * 在库库龄 比较(contains)
   */
  private Integer ageInTheLibraryContains;
  /**
   * 在库库龄 比较(notcontains)
   */
  private Integer ageInTheLibraryNotcontains;
  /**
   * 在库库龄 比较(startswith)
   */
  private Integer ageInTheLibraryStartswith;
  /**
   * 在库库龄 比较(endswith)
   */
  private Integer ageInTheLibraryEndswith;
  /**
   * 在库库龄 比较(isnull)
   */
  private Boolean ageInTheLibraryIsnull;
  /**
   * 在库库龄 比较(isnotnull)
   */
  private Boolean ageInTheLibraryIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
